// 这是vue vnode-patch的部分代码，请逐行解释并用一页代码格式返回
/**
 * Virtual DOM patching algorithm based on Snabbdom by
 * Simon Friis Vindum (@paldepind)
 * Licensed under the MIT License
 * https://github.com/paldepind/snabbdom/blob/master/LICENSE
 *
 * modified by Evan You (@yyx990803)
 *
 * Not type-checking this because this file is perf-critical and the cost
 * of making flow understand it is not worth it.
 */
// Vue.js虚拟DOM diff算法的一部分，主要用于比较新旧虚拟DOM树，并计算出最小的DOM操作集合来更新真实的DOM
import VNode, { cloneVNode } from './vnode'
import config from '../config'
import { SSR_ATTR } from 'shared/constants'
import { registerRef } from './modules/template-ref'
import { traverse } from '../observer/traverse'
import { activeInstance } from '../instance/lifecycle'
import { isTextInputType } from 'web/util/element'

import {
  warn,
  isDef,
  isUndef,
  isTrue,
  isArray,
  makeMap,
  isRegExp,
  isPrimitive
} from '../util/index'

// 定义一个空节点，用于表示不存在的虚拟节点
export const emptyNode = new VNode('', {}, [])
// 定义虚拟DOM操作中可能用到的钩子函数名称数组
const hooks = ['create', 'activate', 'update', 'remove', 'destroy']
// 判断两个虚拟节点是否相同
function sameVnode(a, b) {
  return (
    a.key === b.key && // 比较key是否相同
    a.asyncFactory === b.asyncFactory && // 比较异步工厂函数是否相同
    ((a.tag === b.tag && // 比较标签名是否相同
      a.isComment === b.isComment && // 比较是否为注释节点
      isDef(a.data) === isDef(b.data) && // 比较数据是否都已定义或都未定义
      sameInputType(a, b)) || // 调用sameInputType函数比较输入类型是否相同
      // 如果a是异步占位符且b的异步工厂函数没有错误，也视为相同
      (isTrue(a.isAsyncPlaceholder) && isUndef(b.asyncFactory.error)))
  )
}
// 判断两个input节点的输入类型是否相同
function sameInputType(a, b) {
  // 如果a不是input节点，直接返回true
  if (a.tag !== 'input') return true
  let i // 声明一个变量i，用于临时存储中间结果，但在这段代码中未直接使用
  // 获取a节点的type属性
  const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type
  // 获取b节点的type属性
  const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type
  // 比较type属性是否相同，或者都是文本输入类型
  return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB))
}
// 创建一个从子节点的key到其在旧子节点数组中的索引的映射
function createKeyToOldIdx(children, beginIdx, endIdx) {
  let i, key // 声明变量i用于循环，key用于存储当前子节点的key
  const map = {} // 创建一个空对象作为映射
  for (i = beginIdx; i <= endIdx; ++i) { // 循环遍历指定范围内的子节点
    key = children[i].key // 获取当前子节点的key
    if (isDef(key)) map[key] = i // 如果key已定义，则将其添加到映射中
  }
  return map // 返回映射对象
}

export function createPatchFunction(backend) {
  let i, j // 声明两个变量i和j，用于后续的循环操作。
  const cbs: any = {} // 创建一个空对象cbs，用于存储各种钩子函数的回调数组。
  // 从backend对象解构出modules和nodeOps，它们分别包含Vue的模块和DOM操作函数。
  const { modules, nodeOps } = backend
  // 遍历hooks数组，为每个钩子函数初始化一个空数组，并将对应模块中的钩子函数添加到该数组中。
  for (i = 0; i < hooks.length; ++i) {
    cbs[hooks[i]] = []
    for (j = 0; j < modules.length; ++j) {
      if (isDef(modules[j][hooks[i]])) {
        cbs[hooks[i]].push(modules[j][hooks[i]])
      }
    }
  }
// 创建一个空的VNode，其elm属性指向一个真实的DOM元素，用于表示该元素已被虚拟化。
  function emptyNodeAt(elm) {
    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
  }
// 创建一个移除回调，当所有监听器都被移除后，会真正地从DOM中删除对应的元素。
  function createRmCb(childElm, listeners) {
    function remove() {
      if (--remove.listeners === 0) {
        removeNode(childElm)
      }
    }
    remove.listeners = listeners
    return remove
  }
// 从DOM中移除一个元素，如果该元素仍然存在的话。
  function removeNode(el) {
    const parent = nodeOps.parentNode(el)
    // element may have already been removed due to v-html / v-text
    if (isDef(parent)) {
      nodeOps.removeChild(parent, el)
    }
  }
// 判断一个VNode是否代表一个未知的元素。
  function isUnknownElement(vnode, inVPre) {
    return (
      !inVPre &&
      !vnode.ns &&
      !(
        config.ignoredElements.length &&
        config.ignoredElements.some(ignore => {
          return isRegExp(ignore)
            ? ignore.test(vnode.tag)
            : ignore === vnode.tag
        })
      ) &&
      config.isUnknownElement(vnode.tag)
    )
  }
// 用于跟踪在v-pre指令块中创建的元素数量。
  let creatingElmInVPre = 0
// 创建一个真实的DOM元素，并将其与VNode关联起来。
  function createElm(
    vnode,
    insertedVnodeQueue,
    parentElm?: any,
    refElm?: any,
    nested?: any,
    ownerArray?: any,
    index?: any
  ) {
      // 如果VNode之前已经被使用过，则克隆它以避免潜在的补丁错误。
    if (isDef(vnode.elm) && isDef(ownerArray)) {
      // This vnode was used in a previous render!
      // now it's used as a new node, overwriting its elm would cause
      // potential patch errors down the road when it's used as an insertion
      // reference node. Instead, we clone the node on-demand before creating
      // associated DOM element for it.
      vnode = ownerArray[index] = cloneVNode(vnode)
    }
// 设置isRootInsert标志，用于过渡效果的进入检查。
    vnode.isRootInsert = !nested // for transition enter check
      // 尝试创建一个组件实例。
    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
      return
    }
// 以下的代码处理普通HTML元素的创建。
    const data = vnode.data
    const children = vnode.children
    const tag = vnode.tag
    if (isDef(tag)) {
      // 在开发模式下进行一系列的检查。
      if (__DEV__) {
        if (data && data.pre) {
          creatingElmInVPre++
        }
        if (isUnknownElement(vnode, creatingElmInVPre)) {
          warn(
            'Unknown custom element: <' +
              tag +
              '> - did you ' +
              'register the component correctly? For recursive components, ' +
              'make sure to provide the "name" option.',
            vnode.context
          )
        }
      }
    // 创建元素，并设置其作用域（如果有的话）。
      vnode.elm = vnode.ns
        ? nodeOps.createElementNS(vnode.ns, tag)
        : nodeOps.createElement(tag, vnode)
      setScope(vnode)
    // 递归地创建子元素。
      createChildren(vnode, children, insertedVnodeQueue)
       // 调用创建钩子。
      if (isDef(data)) {
        invokeCreateHooks(vnode, insertedVnodeQueue)
      }
      // 将新创建的元素插入到DOM中。
      insert(parentElm, vnode.elm, refElm)
      // 在开发模式下进行清理。
      if (__DEV__ && data && data.pre) {
        creatingElmInVPre--
      }
    } else if (isTrue(vnode.isComment)) {
      // 创建注释节点。
      // 示例：html的注释节点：<!-- 这是一个注释 -->
      vnode.elm = nodeOps.createComment(vnode.text)
      insert(parentElm, vnode.elm, refElm)
    } else {
      // 创建文本节点。
      vnode.elm = nodeOps.createTextNode(vnode.text)
      insert(parentElm, vnode.elm, refElm)
    }
  }
// 尝试为VNode创建一个组件实例。
  function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
    let i = vnode.data
    if (isDef(i)) {
      const isReactivated = isDef(vnode.componentInstance) && i.keepAlive
      if (isDef((i = i.hook)) && isDef((i = i.init))) {
        i(vnode, false /* hydrating */)
      }
      // after calling the init hook, if the vnode is a child component
      // it should've created a child instance and mounted it. the child
      // component also has set the placeholder vnode's elm.
      // in that case we can just return the element and be done.
      if (isDef(vnode.componentInstance)) {
        initComponent(vnode, insertedVnodeQueue)
        insert(parentElm, vnode.elm, refElm)
        if (isTrue(isReactivated)) {
          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
        }
        return true
      }
    }
  }
// 初始化一个组件实例，并将其与对应的VNode关联起来。
  function initComponent(vnode, insertedVnodeQueue) {
    if (isDef(vnode.data.pendingInsert)) {
      insertedVnodeQueue.push.apply(
        insertedVnodeQueue,
        vnode.data.pendingInsert
      )
      vnode.data.pendingInsert = null
    }
    vnode.elm = vnode.componentInstance.$el
    if (isPatchable(vnode)) {
      invokeCreateHooks(vnode, insertedVnodeQueue)
      setScope(vnode)
    } else {
      // empty component root.
      // skip all element-related modules except for ref (#3455)
      registerRef(vnode)
      // make sure to invoke the insert hook
      insertedVnodeQueue.push(vnode)
    }
  }
// 重新激活组件的函数，用于处理被keep-alive包裹的组件的重新激活
  function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
    let i // 声明一个变量i，用于循环和索引
    // 处理内部有transition的组件重新激活时不触发transition的问题
    // hack for #4339: a reactivated component with inner transition
    // does not trigger because the inner node's created hooks are not called
    // again. It's not ideal to involve module-specific logic in here but
    // there doesn't seem to be a better way to do it.
    let innerNode = vnode // 从最外层的vnode开始
    // 当存在componentInstance时，继续深入
    while (innerNode.componentInstance) {
      innerNode = innerNode.componentInstance._vnode // 获取组件实例对应的vnode
      // 如果存在data和transition
      if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
        // 遍历所有的activate钩子
        for (i = 0; i < cbs.activate.length; ++i) {
          // 执行activate钩子
          cbs.activate[i](emptyNode, innerNode)
        }
         // 将vnode加入插入队列，跳出循环
        insertedVnodeQueue.push(innerNode)
        break
      }
    }
    // unlike a newly created component,
    // a reactivated keep-alive component doesn't insert itself
    // 将vnode的DOM元素插入到父元素中，与新建组件不同，重新激活的keep-alive组件不会自行插入
    insert(parentElm, vnode.elm, refElm)
  }
// 将元素插入到父元素中的函数
  function insert(parent, elm, ref) {
    if (isDef(parent)) { // 如果父元素存在
      if (isDef(ref)) {// 如果存在参考元素
        if (nodeOps.parentNode(ref) === parent) { // 如果参考元素的父元素是目标父元素
          nodeOps.insertBefore(parent, elm, ref) // 在参考元素前插入新元素
        }
      } else {
        nodeOps.appendChild(parent, elm) // 如果没有参考元素，则直接追加到父元素末尾
      }
    }
  }
// 创建子节点的函数
  function createChildren(vnode, children, insertedVnodeQueue) {
    if (isArray(children)) { // 如果children是数组
      if (__DEV__) {
        checkDuplicateKeys(children) // 在开发模式下检查重复的key
      }
      for (let i = 0; i < children.length; ++i) {  
        // 遍历children数组，调用createElm函数创建每个子元素
        createElm(
          children[i],
          insertedVnodeQueue,
          vnode.elm,
          null,
          true,
          children,
          i
        )
      }
  // 如果vnode的text是原始值（字符串或数字），则创建文本节点并追加到vnode的DOM元素中
    } else if (isPrimitive(vnode.text)) {
      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)))
    }
  }
// 判断一个vnode是否可以被打补丁（即是否是一个有效的DOM节点或组件）
  function isPatchable(vnode) {
    // 当存在componentInstance时，继续深入
    while (vnode.componentInstance) {
      //获取组件实例对应的vnode
      vnode = vnode.componentInstance._vnode 
    }
    return isDef(vnode.tag) // 如果vnode有tag属性，则返回true
  }
// 调用创建钩子的函数
  function invokeCreateHooks(vnode, insertedVnodeQueue) {
    for (let i = 0; i < cbs.create.length; ++i) {// 遍历所有的create钩子
      cbs.create[i](emptyNode, vnode) // 执行create钩子
    }
    i = vnode.data.hook // 重用变量i，用于访问vnode的钩子
    if (isDef(i)) {
      if (isDef(i.create)) i.create(emptyNode, vnode) // 如果存在create钩子，则执行
      if (isDef(i.insert)) insertedVnodeQueue.push(vnode) // 如果存在insert钩子，则将vnode加入插入队列
    }
  }

  // set scope id attribute for scoped CSS.
  // this is implemented as a special case to avoid the overhead
  // of going through the normal attribute patching process.
  // 设置作用域ID的函数，用于处理作用域CSS
  function setScope(vnode) {
    let i
    // 如果vnode有fnScopeId，则设置样式作用域
    if (isDef((i = vnode.fnScopeId))) {
      nodeOps.setStyleScope(vnode.elm, i)
    } else {
      // 从当前vnode开始向上查找
      let ancestor = vnode
      while (ancestor) {
        //如果找到有_scopeId的上下文，则设置样式作用域
        if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
          nodeOps.setStyleScope(vnode.elm, i)
        }
        ancestor = ancestor.parent // 继续向上查找
      } 
    }
    // for slot content they should also get the scopeId from the host instance.
    // 对于插槽内容，它们也应该从宿主实例获取作用域ID
    if (
      isDef((i = activeInstance)) &&
      i !== vnode.context &&
      i !== vnode.fnContext &&
      isDef((i = i.$options._scopeId))
    ) {
      nodeOps.setStyleScope(vnode.elm, i)
    }
  }
  // 添加虚拟节点到DOM中
  function addVnodes(
    parentElm,      // 父元素
    refElm,         // 参照元素，新节点将插入到这个元素之前
    vnodes,         // 虚拟节点数组
    startIdx,       // 开始索引
    endIdx,         // 结束索引
    insertedVnodeQueue // 插入的虚拟节点队列
  ) {
    for (; startIdx <= endIdx; ++startIdx) {
      createElm(
        vnodes[startIdx],
        insertedVnodeQueue,
        parentElm,
        refElm,
        false,
        vnodes,
        startIdx
      )
    }
  }
// 定义一个函数，用于调用销毁钩子
  function invokeDestroyHook(vnode) {
    let i, j // 声明两个变量i和j用于循环
    const data = vnode.data // 获取当前虚拟节点的数据对象
    if (isDef(data)) {
      // 如果数据对象存在
      // 检查是否存在钩子对象，并且钩子对象中是否包含destroy方法
      if (isDef((i = data.hook)) && isDef((i = i.destroy))) i(vnode)
        // 遍历全局或局部的销毁钩子数组，并调用它们
      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode)
    }
  // 如果当前虚拟节点有子节点
    if (isDef((i = vnode.children))) {
      // 遍历子节点，并递归调用invokeDestroyHook函数
      for (j = 0; j < vnode.children.length; ++j) {
        invokeDestroyHook(vnode.children[j])
      }
    }
  }
// 定义一个函数，用于移除虚拟节点，并调用相关的钩子
  function removeVnodes(vnodes, startIdx, endIdx) {
    // 遍历指定的虚拟节点索引范围
    for (; startIdx <= endIdx; ++startIdx) {
      const ch = vnodes[startIdx] // 获取当前虚拟节点
      // 如果当前虚拟节点存在
      if (isDef(ch)) {
        // 如果当前虚拟节点是一个元素节点（有标签），调用移除钩子并移除DOM元素，调用销毁钩子进行清理工作
        if (isDef(ch.tag)) {
          removeAndInvokeRemoveHook(ch)
          invokeDestroyHook(ch)
        } else {
          // Text node
          // 文本节点，直接移除对应的DOM元素
          removeNode(ch.elm)
        }
      }
    }
  }
// 定义一个函数，用于移除虚拟节点并调用remove钩子
  function removeAndInvokeRemoveHook(vnode, rm?: any) {
    // 如果传入了rm回调或vnode有数据，则执行以下逻辑
    if (isDef(rm) || isDef(vnode.data)) {
      let i
      const listeners = cbs.remove.length + 1 // 计算remove钩子的监听器数量
      if (isDef(rm)) {
        // we have a recursively passed down rm callback
        // increase the listeners count
        // 如果传入了rm回调，则增加其监听器计数
        rm.listeners += listeners
      } else {
        // directly removing
        // 否则，创建一个新的rm回调
        rm = createRmCb(vnode.elm, listeners)
      }
      // recursively invoke hooks on child component root node
      // 如果vnode有组件实例，并且组件实例的_vnode有数据，则递归调用removeAndInvokeRemoveHook
      if (
        isDef((i = vnode.componentInstance)) &&
        isDef((i = i._vnode)) &&
        isDef(i.data)
      ) {
        removeAndInvokeRemoveHook(i, rm)
      }
      // 遍历全局或局部的remove钩子数组，并调用它们
      for (i = 0; i < cbs.remove.length; ++i) {
        cbs.remove[i](vnode, rm)
      }
      // 如果vnode的数据对象中有remove钩子，则调用它；否则直接调用rm回调
      if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
        i(vnode, rm)
      } else {
        rm()
      }
    } else {
      // 如果没有rm回调且vnode没有数据，则直接移除DOM节点
      removeNode(vnode.elm)
    }
  }
// 定义一个函数，用于更新子节点
  function updateChildren(
    parentElm, // 父DOM元素
    oldCh, // 旧的子虚拟节点数组
    newCh, // 新的子虚拟节点数组
    insertedVnodeQueue, // 插入的虚拟节点队列
    removeOnly // 一个特殊标志，仅由<transition-group>使用，以确保移除元素在离开过渡期间保持正确的相对位置
  ) {
    let oldStartIdx = 0
    let newStartIdx = 0
    let oldEndIdx = oldCh.length - 1
    let oldStartVnode = oldCh[0]
    let oldEndVnode = oldCh[oldEndIdx]
    let newEndIdx = newCh.length - 1
    let newStartVnode = newCh[0]
    let newEndVnode = newCh[newEndIdx]
    let oldKeyToIdx, idxInOld, vnodeToMove, refElm

    // removeOnly is a special flag used only by <transition-group>
    // to ensure removed elements stay in correct relative positions
    // during leaving transitions
    const canMove = !removeOnly

    if (__DEV__) {
      checkDuplicateKeys(newCh)
    }
 // 使用while循环来比较和更新新旧虚拟节点
    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
      if (isUndef(oldStartVnode)) {
        oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
      } else if (isUndef(oldEndVnode)) {
        oldEndVnode = oldCh[--oldEndIdx]
      } else if (sameVnode(oldStartVnode, newStartVnode)) {
        patchVnode(
          oldStartVnode,
          newStartVnode,
          insertedVnodeQueue,
          newCh,
          newStartIdx
        )
        oldStartVnode = oldCh[++oldStartIdx]
        newStartVnode = newCh[++newStartIdx]
      } else if (sameVnode(oldEndVnode, newEndVnode)) {
        patchVnode(
          oldEndVnode,
          newEndVnode,
          insertedVnodeQueue,
          newCh,
          newEndIdx
        )
        oldEndVnode = oldCh[--oldEndIdx]
        newEndVnode = newCh[--newEndIdx]
      } else if (sameVnode(oldStartVnode, newEndVnode)) {
        // Vnode moved right
        patchVnode(
          oldStartVnode,
          newEndVnode,
          insertedVnodeQueue,
          newCh,
          newEndIdx
        )
        canMove &&
          nodeOps.insertBefore(
            parentElm,
            oldStartVnode.elm,
            nodeOps.nextSibling(oldEndVnode.elm)
          )
        oldStartVnode = oldCh[++oldStartIdx]
        newEndVnode = newCh[--newEndIdx]
      } else if (sameVnode(oldEndVnode, newStartVnode)) {
        // Vnode moved left
        patchVnode(
          oldEndVnode,
          newStartVnode,
          insertedVnodeQueue,
          newCh,
          newStartIdx
        )
        canMove &&
          nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
        oldEndVnode = oldCh[--oldEndIdx]
        newStartVnode = newCh[++newStartIdx]
      } else {
        if (isUndef(oldKeyToIdx))
          oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
        idxInOld = isDef(newStartVnode.key)
          ? oldKeyToIdx[newStartVnode.key]
          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
        if (isUndef(idxInOld)) {
          // New element
          createElm(
            newStartVnode,
            insertedVnodeQueue,
            parentElm,
            oldStartVnode.elm,
            false,
            newCh,
            newStartIdx
          )
        } else {
          vnodeToMove = oldCh[idxInOld]
          if (sameVnode(vnodeToMove, newStartVnode)) {
            patchVnode(
              vnodeToMove,
              newStartVnode,
              insertedVnodeQueue,
              newCh,
              newStartIdx
            )
            oldCh[idxInOld] = undefined
            canMove &&
              nodeOps.insertBefore(
                parentElm,
                vnodeToMove.elm,
                oldStartVnode.elm
              )
          } else {
            // same key but different element. treat as new element
            createElm(
              newStartVnode,
              insertedVnodeQueue,
              parentElm,
              oldStartVnode.elm,
              false,
              newCh,
              newStartIdx
            )
          }
        }
        newStartVnode = newCh[++newStartIdx]
      }
    }
    // 如果旧节点数组还有剩余，则添加新节点
    if (oldStartIdx > oldEndIdx) {
      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
      addVnodes(
        parentElm,
        refElm,
        newCh,
        newStartIdx,
        newEndIdx,
        insertedVnodeQueue
      )
      // 如果新节点数组还有剩余，则移除旧节点
    } else if (newStartIdx > newEndIdx) {
      removeVnodes(oldCh, oldStartIdx, oldEndIdx)
    }
  }
// 定义一个函数，用于检查子虚拟节点数组中是否有重复的key
  function checkDuplicateKeys(children) {
    const seenKeys = {} // 用于记录已有的key
    // 遍历子节点并获取key
    for (let i = 0; i < children.length; i++) {
      const vnode = children[i]
      const key = vnode.key
      if (isDef(key)) {
        // 如果已见过该key，则发出警告；否则，记录该key
        if (seenKeys[key]) {
          warn(
            `Duplicate keys detected: '${key}'. This may cause an update error.`,
            vnode.context
          )
        } else {
          seenKeys[key] = true
        }
      }
    }
  }
// 在旧子节点数组中寻找与新节点相同的节点索引
  function findIdxInOld(node, oldCh, start, end) {
    for (let i = start; i < end; i++) {
      const c = oldCh[i]// 获取旧子节点数组中的当前节点
      // 如果节点存在且与新节点相同，则返回其索引
      if (isDef(c) && sameVnode(node, c)) return i
      
    }
  }
  // 更新DOM
  function patchVnode(
    oldVnode,
    vnode,
    insertedVnodeQueue,
    ownerArray,
    index,
    removeOnly?: any
  ) {
    // 如果新旧节点相同，则直接返回
    if (oldVnode === vnode) {
      return
    }
  // 如果vnode的DOM元素和ownerArray存在，则克隆vnode
    if (isDef(vnode.elm) && isDef(ownerArray)) {
      // clone reused vnode
      vnode = ownerArray[index] = cloneVNode(vnode)
    }
  // 将新节点的DOM元素设置为旧节点的DOM元素
    const elm = (vnode.elm = oldVnode.elm)

    if (isTrue(oldVnode.isAsyncPlaceholder)) {
      // 如果异步组件已解析，则进行hydrate操作 ，否则，保留异步占位符状态 
      if (isDef(vnode.asyncFactory.resolved)) {
        hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
      } else {
        vnode.isAsyncPlaceholder = true
      }
      return
    }

    // reuse element for static trees.
    // note we only do this if the vnode is cloned -
    // if the new node is not cloned it means the render functions have been
    // reset by the hot-reload-api and we need to do a proper re-render.
    //对于静态树，如果新旧节点都是静态的、key相同，并且新节点是克隆的或只渲染一次的，则复用DOM元素
    if (
      isTrue(vnode.isStatic) &&
      isTrue(oldVnode.isStatic) &&
      vnode.key === oldVnode.key &&
      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
    ) {
      vnode.componentInstance = oldVnode.componentInstance
      return
    }

    let i
    const data = vnode.data
    if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
      i(oldVnode, vnode)
    }

    const oldCh = oldVnode.children
    const ch = vnode.children
    if (isDef(data) && isPatchable(vnode)) {
      // 调用全局更新钩子
      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode)
      // 调用update钩子
      if (isDef((i = data.hook)) && isDef((i = i.update))) i(oldVnode, vnode)
    }
    if (isUndef(vnode.text)) {
      if (isDef(oldCh) && isDef(ch)) {
        if (oldCh !== ch)
          // 更新子节点
          updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
      } else if (isDef(ch)) {
        if (__DEV__) { // 开发模式下检查重复的key
          checkDuplicateKeys(ch)
        }
        // 如果旧节点有文本内容，则清空
        if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
          // 添加新子节点
        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
      } else if (isDef(oldCh)) {
        removeVnodes(oldCh, 0, oldCh.length - 1) // 移除旧子节点
      } else if (isDef(oldVnode.text)) {
        nodeOps.setTextContent(elm, '') // 如果旧节点有文本内容，则清空
      }
    } else if (oldVnode.text !== vnode.text) {
      nodeOps.setTextContent(elm, vnode.text) // 更新文本内容
    }
    if (isDef(data)) {
      // 调用postpatch钩子
      if (isDef((i = data.hook)) && isDef((i = i.postpatch))) i(oldVnode, vnode)
    }
  }
// 调用插入钩子，如果是组件根节点，则延迟到元素真正插入后调用
// 延迟组件根节点的插入钩子，在元素真正插入后调用它们
  function invokeInsertHook(vnode, queue, initial) {
    // delay insert hooks for component root nodes, invoke them after the
    // element is really inserted
    if (isTrue(initial) && isDef(vnode.parent)) {
      vnode.parent.data.pendingInsert = queue // 延迟插入
    } else {
      for (let i = 0; i < queue.length; ++i) {
        queue[i].data.hook.insert(queue[i])// 调用插入钩子 
      }
    }
  }

  let hydrationBailed = false
  // list of modules that can skip create hook during hydration because they
  // are already rendered on the client or has no need for initialization
  // Note: style is excluded because it relies on initial clone for future
  // deep updates (#7063).
  // 创建一个映射，用于快速检查哪些属性是渲染模块的一部分
  const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key')

  // Note: this is a browser-only function so we can assume elms are DOM nodes.
  //这是一个仅适用于浏览器的函数，因此我们可以假设elms是DOM节点。
  function hydrate(elm, vnode, insertedVnodeQueue, inVPre?: boolean) {
    let i
    const { tag, data, children } = vnode  // 解构VNode对象获取标签、数据和子节点
    inVPre = inVPre || (data && data.pre) // 检查是否处于v-pre指令中
    vnode.elm = elm // 将真实DOM元素与VNode关联
// 处理异步组件占位符
    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
      vnode.isAsyncPlaceholder = true
      return true
    }
    // assert node match
     // 开发模式下断言节点匹配
    if (__DEV__) {
      if (!assertNodeMatch(elm, vnode, inVPre)) {
        return false
      }
    }
    // 处理VNode的数据
    if (isDef(data)) {
      // 调用初始化钩子
      if (isDef((i = data.hook)) && isDef((i = i.init)))
        i(vnode, true /* hydrating */)
      // 处理组件实例
      if (isDef((i = vnode.componentInstance))) {
        // child component. it should have hydrated its own tree.
        initComponent(vnode, insertedVnodeQueue)
        return true
      }
    }
    // 处理标签
    if (isDef(tag)) {
      if (isDef(children)) {
        // empty element, allow client to pick up and populate children
        // 空元素，允许客户端拾取和填充子节点
        if (!elm.hasChildNodes()) {
          createChildren(vnode, children, insertedVnodeQueue)
        } else {
          // v-html and domProps: innerHTML
          // 处理v-html和domProps: innerHTML
          if (
            isDef((i = data)) &&
            isDef((i = i.domProps)) &&
            isDef((i = i.innerHTML))
          ) {
            if (i !== elm.innerHTML) {
              /* istanbul ignore if */
              if (
                __DEV__ &&
                typeof console !== 'undefined' &&
                !hydrationBailed
              ) {
                hydrationBailed = true
                console.warn('Parent: ', elm)
                console.warn('server innerHTML: ', i)
                console.warn('client innerHTML: ', elm.innerHTML)
              }
              return false
            }
          } else {
            // iterate and compare children lists
            // 迭代并比较子节点列表
            let childrenMatch = true
            let childNode = elm.firstChild
            for (let i = 0; i < children.length; i++) {
              if (
                !childNode ||
                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)
              ) {
                childrenMatch = false
                break
              }
              childNode = childNode.nextSibling
            }
            // if childNode is not null, it means the actual childNodes list is
            // longer than the virtual children list.
            if (!childrenMatch || childNode) {
              /* istanbul ignore if */
              if (
                __DEV__ &&
                typeof console !== 'undefined' &&
                !hydrationBailed
              ) {
                hydrationBailed = true
                console.warn('Parent: ', elm)
                console.warn(
                  'Mismatching childNodes vs. VNodes: ',
                  elm.childNodes,
                  children
                )
              }
              return false
            }
          }
        }
      }
      // 处理VNode的数据属性
      if (isDef(data)) {
        let fullInvoke = false
        for (const key in data) {
          if (!isRenderedModule(key)) {
            fullInvoke = true
            invokeCreateHooks(vnode, insertedVnodeQueue)
            break
          }
        }
        if (!fullInvoke && data['class']) {
          // ensure collecting deps for deep class bindings for future updates
          traverse(data['class'])
        }
      }
    } else if (elm.data !== vnode.text) {
      // 处理文本节点
      elm.data = vnode.text
    }
    return true
  }
// 检查虚拟节点(vnode)与实际节点(node)是否匹配
  function assertNodeMatch(node, vnode, inVPre) {
    // 如果vnode有标签
    if (isDef(vnode.tag)) {
      return (
        vnode.tag.indexOf('vue-component') === 0 || //检查是否是Vue组件
        // 如果不是未知元素且标签名相同
        (!isUnknownElement(vnode, inVPre) && vnode.tag.toLowerCase() ===(node.tagName && node.tagName.toLowerCase()))
      )
    } else {
      // 如果没有标签，检查是否为注释节点或文本节点
      return node.nodeType === (vnode.isComment ? 8 : 3)
    }
  }
// patch函数，用于将虚拟节点(vnode)应用到真实DOM中
  return function patch(oldVnode, vnode, hydrating, removeOnly) {
    // 如果没有新的vnode
    if (isUndef(vnode)) {
      // 销毁旧的vnode
      if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
      return
    }

    let isInitialPatch = false // 是否是初次打补丁
    const insertedVnodeQueue: any[] = [] // 存储插入的vnode队列
    // 如果没有旧的vnode，标记为初次打补丁并创建新的元素
    if (isUndef(oldVnode)) {
      // empty mount (likely as component), create new root element
      isInitialPatch = true
      createElm(vnode, insertedVnodeQueue)
    } else {
       // 检查旧的vnode是否为真实DOM元素
      const isRealElement = isDef(oldVnode.nodeType)
      // 如果旧的vnode不是真实DOM且与新vnode相同
      if (!isRealElement && sameVnode(oldVnode, vnode)) {
        // patch existing root node
        // 更新现有节点
        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
      } else {
        // 如果旧的vnode是真实DOM
        if (isRealElement) {
          // mounting to a real element
          // check if this is server-rendered content and if we can perform
          // a successful hydration.
          // 检查是否可以进行服务端渲染(SSR)的水合(hydration)
          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
            oldVnode.removeAttribute(SSR_ATTR)
            hydrating = true
          }
          if (isTrue(hydrating)) {
            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
              invokeInsertHook(vnode, insertedVnodeQueue, true)
              return oldVnode
            } else if (__DEV__) {
              // warn('客户端渲染的虚拟DOM树与服务端渲染的内容不匹配...')
              warn(
                'The client-side rendered virtual DOM tree is not matching ' +
                  'server-rendered content. This is likely caused by incorrect ' +
                  'HTML markup, for example nesting block-level elements inside ' +
                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
                  'full client-side render.'
              )
            }
          }
          // either not server-rendered, or hydration failed.
          // create an empty node and replace it
          // 如果不能水合，则创建一个空节点并替换它
          oldVnode = emptyNodeAt(oldVnode)
        }

        // replacing existing element
        // 替换现有元素
        const oldElm = oldVnode.elm
        const parentElm = nodeOps.parentNode(oldElm)

        // create new node
        // 创建新元素
        createElm(
          vnode,
          insertedVnodeQueue,
          // extremely rare edge case: do not insert if old element is in a
          // leaving transition. Only happens when combining transition +
          // keep-alive + HOCs. (#4590)
          oldElm._leaveCb ? null : parentElm,
          nodeOps.nextSibling(oldElm)
        )

        // update parent placeholder node element, recursively
         // 更新父节点的占位符元素，递归处理
        if (isDef(vnode.parent)) {
          let ancestor = vnode.parent
          const patchable = isPatchable(vnode)
          while (ancestor) {
            for (let i = 0; i < cbs.destroy.length; ++i) {
              cbs.destroy[i](ancestor)
            }
            ancestor.elm = vnode.elm
            if (patchable) {
              for (let i = 0; i < cbs.create.length; ++i) {
                cbs.create[i](emptyNode, ancestor)
              }
              // #6513
              // invoke insert hooks that may have been merged by create hooks.
              // e.g. for directives that uses the "inserted" hook.
              const insert = ancestor.data.hook.insert
              if (insert.merged) {
                // start at index 1 to avoid re-invoking component mounted hook
                // clone insert hooks to avoid being mutated during iteration.
                // e.g. for customed directives under transition group.
                const cloned = insert.fns.slice(1)
                for (let i = 0; i < cloned.length; i++) {
                  cloned[i]()
                }
              }
            } else {
              registerRef(ancestor)
            }
            ancestor = ancestor.parent
          }
        }

        // destroy old node
        // 销毁旧节点
        if (isDef(parentElm)) {
          removeVnodes([oldVnode], 0, 0)
        } else if (isDef(oldVnode.tag)) {
          invokeDestroyHook(oldVnode)
        }
      }
    }
    // 调用插入钩子，返回新创建的DOM元素
    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
    return vnode.elm
  }
}
